Chip 2007 January, February, March & April/Chip-Cover-CD-2007-02.iso/Pakiet bezpieczenstwa/mini Pentoo LiveCD 2006.1/mpentoo-2006.1.iso/livecd.squashfs/usr/share/pygtk/2.0/codegen/defsparser.pyc

Python Compiled Bytecode | 2006-01-20 | 6KB | 187 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.4)

import os
import sys
import scmexpr
from definitions import *

class IncludeParser(scmexpr.Parser):
    '''A simple parser that follows include statements automatically'''

    def include(self, filename):
        if not os.path.isabs(filename):
            filename = os.path.join(os.path.dirname(self.filename), filename)

        oldfile = self.filename
        self.filename = filename
        self.startParsing()
        self.filename = oldfile



class DefsParser(IncludeParser):

    def __init__(self, arg, defines = { }):
        IncludeParser.__init__(self, arg)
        self.objects = []
        self.interfaces = []
        self.enums = []
        self.boxes = []
        self.pointers = []
        self.functions = []
        self.virtuals = []
        self.c_name = { }
        self.methods = { }
        self.defines = defines


    def define_object(self, *args):
        odef = apply(ObjectDef, args)
        self.objects.append(odef)
        self.c_name[odef.c_name] = odef


    def define_interface(self, *args):
        idef = apply(InterfaceDef, args)
        self.interfaces.append(idef)
        self.c_name[idef.c_name] = idef


    def define_enum(self, *args):
        edef = apply(EnumDef, args)
        self.enums.append(edef)
        self.c_name[edef.c_name] = edef


    def define_flags(self, *args):
        fdef = apply(FlagsDef, args)
        self.enums.append(fdef)
        self.c_name[fdef.c_name] = fdef


    def define_boxed(self, *args):
        bdef = apply(BoxedDef, args)
        self.boxes.append(bdef)
        self.c_name[bdef.c_name] = bdef


    def define_pointer(self, *args):
        pdef = apply(PointerDef, args)
        self.pointers.append(pdef)
        self.c_name[pdef.c_name] = pdef


    def define_function(self, *args):
        fdef = apply(FunctionDef, args)
        self.functions.append(fdef)
        self.c_name[fdef.c_name] = fdef


    def define_method(self, *args):
        mdef = apply(MethodDef, args)
        self.functions.append(mdef)
        self.c_name[mdef.c_name] = mdef


    def define_virtual(self, *args):
        vdef = apply(VirtualDef, args)
        self.virtuals.append(vdef)


    def merge(self, old, parmerge):
        for obj in self.objects:
            if old.c_name.has_key(obj.c_name):
                obj.merge(old.c_name[obj.c_name])
                continue

        for f in self.functions:
            if old.c_name.has_key(f.c_name):
                f.merge(old.c_name[f.c_name], parmerge)
                continue



    def printMissing(self, old):
        for obj in self.objects:
            if not old.c_name.has_key(obj.c_name):
                obj.write_defs()
                continue

        for f in self.functions:
            if not old.c_name.has_key(f.c_name):
                f.write_defs()
                continue



    def write_defs(self, fp = sys.stdout):
        for obj in self.objects:
            obj.write_defs(fp)

        for enum in self.enums:
            enum.write_defs(fp)

        for boxed in self.boxes:
            boxed.write_defs(fp)

        for pointer in self.pointers:
            pointer.write_defs(fp)

        for func in self.functions:
            func.write_defs(fp)



    def find_object(self, c_name):
        for obj in self.objects:
            if obj.c_name == c_name:
                return obj
                continue
        else:
            raise ValueError, 'object not found'


    def find_constructor(self, obj, overrides):
        for func in self.functions:
            if isinstance(func, FunctionDef) and func.is_constructor_of == obj.c_name and not overrides.is_ignored(func.c_name):
                return func
                continue



    def find_methods(self, obj):
        objname = obj.c_name
        return filter((lambda func, on = objname: if isinstance(func, MethodDef):
passfunc.of_object == on), self.functions)


    def find_virtuals(self, obj):
        objname = obj.c_name
        retval = filter((lambda func, on = objname: if isinstance(func, VirtualDef):
passfunc.of_object == on), self.virtuals)
        return retval


    def find_functions(self):
        return filter((lambda func: if isinstance(func, FunctionDef):
passnot (func.is_constructor_of)), self.functions)


    def ifdef(self, *args):
        if args[0] in self.defines:
            for arg in args[1:]:
                self.handle(arg)




    def ifndef(self, *args):
        if args[0] not in self.defines:
            for arg in args[1:]:
                self.handle(arg)